Internet Info 1994 March

home *** CD-ROM | disk | FTP | other *** search

/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / terms / kermit / a / mssscp.asm < prev next >

Wrap

Assembly Source File | 1993-07-12 | 75.7 KB | 2,349 lines

NAME mssscp ; File MSSSCP.ASM include mssdef.h ; Copyright (C) 1985, 1993, Trustees of Columbia University in the ; City of New York. Permission is granted to any individual or institution ; to use this software as long as it is not sold for profit. This copyright ; notice must be retained. This software may not be included in commercial ; products without written permission of Columbia University. ; ; Edit History ; 27 August 1992 version 3.13 ; 6 Sept 1991 version 3.11 ; Last edit 19 Jan 1993 ; 4 June 1991 Make label searches be global so the next higher level is ; searched if the present level does not contain the target. ; 6 June 1989 Limit echoing of received chars by OUTPUT to 100, to quench ; verbose hosts. From Dan Norstedt. ; 4 May 1989 Make input/reinput scan buffer be allocated dynamically. Allow ; for that size to be set via Environment as Kermit initializes. ; ; MS Kermit Script routines, DEC-20 style. ; Extensively rewritten for MS Kermit 2.29a by Joe R. Doupnik 5 July 86 ;; ; Created June, 1986 a.d. By James Sturdevant ; A. C. Nielsen Co. Mpls. ; 8401 Wayzata Blvd. ; Minneapolis, Mn. 55426 ; (612)546-0600 ;;;;;;;; ; Kermit command level usages and this file's entry points: ; Clear - clears serial port buffers. Procedure scclr. ; Echo text - displays text on local screen. Proc scecho. ; Pause [time] - waits indicated number of seconds (default is Input ; Default-timeout, 1 second typically). Proc scpau. ; IF condtion command - tests condition (SUCCESS or FAILURE just now) and ; if the condition is met executes the main-line Kermit command. ; GOTO label - rewinds Take file or Macro, locates the :label, transfers ; parsing control to the next line. ; Input [time] text - waits up to time seconds while scanning serial port ; input for a match with text. Default value for time is Input ; Default-timeout, 1 second typically). Spaces or tabs are separators ; between the time and text fields. Proc scinp. ; A carriage return typed by the local user simulates a match. ; Reinput [time] text - like INPUT but non-destructively rereads the 128 byte ; script buffer. Buffer can be added to, until full, if necessary. ; Output text - sends the text to the serial output port. Proc scout. ; Transmit text [prompt] - raw file transfer to host. Proceeds from source ; line to source line upon receipt of prompt from host or carriage ; return from us. Default prompt is linefeed. A null prompt (\0) ; causes the file to be sent with no pausing or handshaking. Note ; that linefeeds are stripped from outgoing material. Proc scxmit. ; In the above commands "text" may be replaced by "@filespec" to cause the ; one line of that file to be used instead. @CON obtains one line of ; text from the keyboard. Such "indirect command files" may be nested ; to a depth of 100. Control codes are written as decimal numbers ; in the form "\ddd" where d is a digit between 0 and 9. Carriage ; return is \13, linefeed is \10, bell is \7; the special code \255 ; is used to match (Input) either cr or lf or both. ; These commands can be given individually by hand or automatically ; in a Kermit Take file; Take files may be nested. ;;;;;;;; ; These routines expect to be invoked by the Kermit command dispatcher ; and can have their default operations controlled by the Kermit Set Input ; command (implemented in file mssset.asm). They parse their own cmd lines. ; Set Input accepts arguments of ; Case Ignore or Observe (default is ignore case when matching strings) ; Default-timeout seconds (default is 5 seconds) ; Echo On or Off controls echoing of Input cmd text (default is Off) ; Timeout-action Quit or Proceed (default is Proceed) ; These conditions are passed via global variables script.incasv, .indfto, ; .inecho, .inactv, respectively, stored here in structure script. ;;;;;;;;; public script, scout, scinp, scpau, scecho, scclr, scxmit, scwait public sgoto, screinp, ifcmd, setalrm, inptim, chktmo, alrhms public buflog, scpini, scpbuflen, decvar, incvar, scmpause, outpace linelen equ 134 ; length of working buffer line maxtry equ 5 ; maximum number of output retries stat_unk equ 0 ; status return codes. stat_ok equ 1 ; have a port character stat_cc equ 2 ; control-C typed stat_tmo equ 4 ; timeout stat_cr equ 8 ; carriage return typed ifsuc equ 0 ; indicators for IF conditions iffail equ 1 ifext equ 2 iferr equ 3 ifnot equ 4 ifctr equ 5 ifmdf equ 6 ifalarm equ 7 ifequal equ 8 ifless equ 9 ifsame equ 10 ifmore equ 11 ifllt equ 12 iflgt equ 13 ifpath equ 14 data segment extrn taklev:byte, takadr:word, portval:word, flags:byte extrn rxtable:byte, spause:byte, errlev:byte, fsta:word extrn kstatus:word, mcctab:byte, comand:byte, ttyact:byte extrn keyboard:word, rdbuf:byte, apctrap:byte ; global (public) variables script scptinfo <> ; global structure, containing: ;;inactv db 0 ; input action value (default proceed) ;;incasv db 0dfh ; input case (default ignore) ;;indfto dw 1 ; input and pause timeout (def 1 sec) ;;inecho db 1 ; echo Input cmd text (0 = no) ;;xmitfill db 0 ; non-zero to TRANSMIT filler ;;xmitlf db 0 ; non-zero to TRANSMIT LF's ;;xmitpmt db lf ; prompt between lines ; local variables line db linelen+1 dup (0) ; line of output or input + terminator even scpbuflen dw 128 ; serial port local buffer def length bufcnt dw 0 ; serial port buf byte cnt, must be 0 bufseg dw 0 ; segment of buffer bufrdptr dw 0 ; serial port buf read ptr bufwtptr dw 0 ; serial port buf write ptr bufpkptr dw 0 ; peek-read pointer bufpkcnt dw 0 ; peek-read byte count remaining inplen dw 0 ; length of input match string reinflg db 0 ; 0 = INPUT, else REINPUT command notflag db 0 ; IF NOT flag slablen dw 0 ; label length, for GOTO status dw 0 ; general status word fhandle dw 0 ; file handle storage place temptr dw 0 ; temporary pointer temptr2 dw 0 ; ditto, points to end of INPUT string tempd dw 0 ; temp temp dw 0 ; a temp tempa db 0 ; another temp wtemp db 0 ; temp for WAIT ltype db 0 ; lex type for IF statements retry db 0 ; number of output retries parmsk db 7fh ; 7/8 bit parity mask lecho db 0 ; local echo of output (0 = no) timout dw 0 ; work area (seconds before timeout) timhms db 4 dup (0) ; hhmmss.s time of day buffer alrhms db 4 dup (0) ; hhmmss.s time of day alarm buffer outpace dw 0 ; OUTPUT pacing, millisec eolchr db LF ; end of line character crlf db cr,lf,'$' xfrfnf db cr,lf,'?Transmit file not found$' xfrrer db cr,lf,'?error reading Transmit file$' xfrcan db cr,lf,'?Transmission canceled$' indmis db '?Indirect file not found',cr,lf,'$' inderr db '?error reading indirect file',cr,lf,'$' laberr db cr,lf,'?Label ":$' laberr2 db '" was not found.',cr,lf,'$' tmomsg db cr,lf,'?Timeout',cr,'$' outhlp db 'line of text to be sent to remote host$' inphlp db 'time-limit and line of text expected from remote host' db cr,lf,' Time is number of seconds or until a specific' db ' hh:mm:ss (24 hour clock)$' echhlp db 'line of text to be Echoed to screen$' ptshlp db 'amount of time to pause/wait' db cr,lf,' Time is number of seconds or until a specific' db ' hh:mm:ss (24 hour clock)$' wthlp db cr,lf,'Optional modem status signals CD, CTS, DSR, RI which' db ' if asserted',cr,lf,' will terminate waiting$' wtbad db cr,lf,'?Command not understood, improper syntax$' xmthlp db ' Name of file to be Transmitted$' pmthlp db cr,lf db ' Prompt character expected as an ACK from host (\0 for none)$' ifdfhlp db cr,lf,' Name of macro or variable then a command$' alrmhlp db cr,lf,' Seconds from now or time of day (HH:MM:SS) for alarm,' db ' < 12H from present$' mphlp db cr,lf,' Number of milliseconds to pause (0..65535)$' mpbad db cr,lf,'?Bad number$' ifmhlp db cr,lf,' Number, ARGC (1+argument count), COUNT, ERRORLEVEL,' db ' KEYBOARD, VERSION$' ifnhlp db cr,lf,' Number which errorlevel should match or exceed$' ifnmsg db cr,lf,'?Number expected, ignoring "$' ifnmsg2 db '"$' discard db ' Kermit command' db cr,lf,' "IF" condition is false, command will be ignored.$' ifehlp1 db cr,lf,'?pair of words or variables to be compared$' ifehlp2 db cr,lf,'?second word or variable to be compared$' chgvarhlp db 'name of variable$' ssizehlp db 'amount, default is 1$' clrhelp db cr,lf,' INPUT-BUFFER (script string matching buffer), or' db cr,lf,' DEVICE-BUFFER (comms receive), or BOTH$' clrtable db 3 mkeyw "input-buffer",1 mkeyw "device-buffer",2 mkeyw "both",3 iftable db 15 ; IF command dispatch table mkeyw 'Not',ifnot mkeyw '<',ifless mkeyw '=',ifsame mkeyw '>',ifmore mkeyw 'Alarm',ifalarm mkeyw 'Count',ifctr mkeyw 'Defined',ifmdf mkeyw 'Errorlevel',iferr mkeyw 'Equal',ifequal mkeyw 'Exist',ifext mkeyw 'Inpath',ifpath mkeyw 'LGT',iflgt mkeyw 'LLT',ifllt mkeyw 'Failure',iffail mkeyw 'Success',ifsuc data ends code segment extrn comnd:near, clrbuf:near, prtchr:near, outchr:near, sendbr:near extrn cptchr:near, serini:near, pcwait:near, katoi:near, spath:near extrn cnvstr:near, getmodem:near, isdev:near, isfile:near extrn takrd:near, takclos:near, tolowr:near, prtasz:near,strlen:near extrn sendbl:near, dec2di:near assume cs:code, ds:data, es:nothing ; Initialize script routines before use, called as Kermit initializes. SCPINI PROC NEAR mov cx,scpbuflen ; (RE)INPUT buffer length mov bx,cx ; string length, in bytes add bx,15 ; round up jnc scpini1 ; nc = under max size scpini3:mov bx,0ffffh ; 64KB-16 bytes, max buffer scpini1:mov cl,4 shr bx,cl ; convert to paragraphs (divide by 16) scpini2:mov cx,bx ; remember desired paragraphs mov ah,alloc ; allocate a memory block int dos jc scpini4 ; error, not enough memory mov bufseg,ax ; store new segment mov cl,4 shl bx,cl ; convert paragraphs to bytes mov scpbuflen,bx ; new length push es mov es,ax ; buffer segment xor di,di ; offset mov cx,bx ; length in bytes shr cx,1 ; even, do words xor ax,ax ; null filler cld rep stosw ; clear the buffer pop es clc ; return success ret scpini4:mov scpbuflen,0 stc ; carry set for failure to initialize ret SCPINI ENDP ; Clear input buffer(s) of serial port ; Clear command ; SCCLR PROC NEAR mov comand.cmcr,1 ; permit empty line mov ah,cmkey mov dx,offset clrtable mov bx,offset clrhelp call comnd mov comand.cmcr,0 mov kstatus,kssuc ; global status push bx ; cmd return mov ah,cmeol ; get a confirm call comnd pop bx jnc scclr1 ; nc = success ret ; failure scclr1: cmp bx,1 jne scclr2 call bufclear clc ret scclr2: cmp bx,2 jne scclr3 ; default, gibberish bx call clrbuf clc ret scclr3: call bufclear ; clear our serial port circular buf call clrbuf ; clear system serial port buffer too clc ret SCCLR ENDP ; ; Echo a line of text to our screen ; Echo text ; SCECHO PROC NEAR mov ah,cmline ; get a whole line of asciiz text mov bx,offset rdbuf ; where to store in mov word ptr [bx],0 ; clear line mov comand.cmblen,cmdblen ; set line capacity (length of rdbuf) mov dx,offset echhlp ; help call comnd jc echo3 mov ah,cmeol call comnd jc echo3 mov si,offset rdbuf ; start of line mov di,si ; convert to the same place mov ah,script.incasv ; save current case state push ax mov script.incasv,0ffh ; say no case conversion call cnvlin ; convert \numbers to binary pop ax mov script.incasv,ah ; recover case state jc echo3 ; carry set means error mov ah,prstr mov dx,offset crlf int dos jcxz echo2 ; z = nothing to show cld echo1: lodsb ; get a source char into al mov dl,al mov ah,conout int dos loop echo1 ; get another echo2: clc ; return success echo3: ret ; error SCECHO ENDP ; Extract label from command line. Store in LINE, length in slablen. ; Jump to line in Take or Macro following that label. SGOTO PROC NEAR mov kstatus,kssuc ; global status mov ah,cmword ; get a word mov dx,offset line ; buffer to hold label xor bx,bx ; no help (non-interactive command) mov slablen,bx ; clear label holding buffer mov comand.cmkeep,1 ; keep Take/macro open after EOF call comnd jnc goto1 ; nc = success ret ; failure goto1: mov ax,ax ; byte count mov slablen,ax ; save count here or ax,ax ; need contents jz goto3 ; empty, fail mov comand.cmkeep,1 ; keep Take file open after this call mov ah,cmeol call comnd jnc goto2 ; nc = success ret ; failure goto2: cmp flags.cxzflg,'C' ; check for Control-C breakout je goto3 ; e = yes, fail cmp taklev,0 ; in a Take file or Macro? jne GETTO ; ne = yes, find the label clc ; ignore interactive command ret goto3: stc ret ; Find line starting just after ":label". Label is in variable LINE ; (length in slablen). Readjust Take read pointer to start of that line. ; Performs file search from beginning of file, popping up levels if req'd. ; Exit carry clear if success, carry set otherwise. Local worker routine. getto proc near push bx ; global save of bx gett0: mov bx,takadr cmp [bx].taktyp,0feh ; get type of take (a file?) jne gett2 ; ne = no, a macro ; scan from start of Take file mov eolchr,LF ; file lines end on LF mov bx,[bx].takhnd ; rewind the file xor cx,cx xor dx,dx xor al,al ; zero displacement from start of file mov ah,lseek int dos jnc gett1 jmp gett20 ; c = failure gett1: call takrd ; get a buffer of data mov bx,takadr ; restore bx to working value jmp short gett4 ; Take a Macro gett2: mov eolchr,CR ; Macro lines end on CR mov cx,[bx].takbuf ; segment of macro definition push es mov es,cx mov cx,es:[0] ; get string length byte pop es mov [bx].takcnt,cx ; set unread to full buffer (rewind) mov [bx].takptr,2 ; set read pointer to start of text gett4: call getch ; get a character jc gett14 ; c = end of file, no char cmp al,' ' ; leading white space? je gett4 ; e = yes, read again cmp al,TAB je gett4 cmp al,':' ; start of label? je gett8 ; e = yes gett6: cmp al,eolchr ; end of line? je gett4 ; e = yes, seek colon for label call getch ; get a character jc gett14 ; c = end of file, no char jmp short gett6 ; read until end of line gett8: mov si,offset line ; label to search for mov cx,slablen ; its length jcxz gett12 ; no chars to match cmp byte ptr[si],':' ; user label starts with colon jne gett10 ; ne = no inc si ; skip user's colon dec cx jcxz gett12 ; no chars to match gett10: call getch ; read file char into al jc gett14 ; c = end of file mov ah,al cld lodsb call tolowr ; convert al and ah to lower case cmp al,ah ; match? jne gett6 ; ne = no, goto end of line loop gett10 ; continue matching ; match obtained call getch ; read next file character jc gett13 ; c = end of file, no char cmp al,' ' ; separator? je gett12 ; e = yes, unique label found cmp al,TAB ; this kind of separator? je gett12 ; e = yes cmp al,eolchr ; or end of line? je gett13 ; e = yes cmp al,CR ; macro eol, also file start eol pair jne gett6 ; ne = longer label than target gett12: call getch ; read past end of line jc gett13 ; c = end of file, no char cmp al,eolchr ; end of line character? jne gett12 ; ne = no, keep reading gett13: pop bx clc ; return carry clear ret ; Take pointers are ready to read line ; failed to find label, pop a level gett14: call takclos ; close this macro/take file cmp taklev,0 ; still in macro/take? je gett15 ; e = no, quit jmp gett0 ; try next level up gett15:mov ah,prstr ; say label not found mov dx,offset laberr ; first part of error message int dos mov dx,offset line cmp line,':' ; label starts with ":"? jne gett16 ; ne = no inc dx ; yes, skip it gett16: call prtasz ; print asciiz string mov ah,prstr mov dx,offset laberr2 ; trailer of error message int dos gett20: pop bx mov kstatus,ksgen ; command status, failure stc ; set carry for failure ret getto endp SGOTO ENDP ; Read char from Take buffer. Returns carry clear and char in al, or if end ; of file returns carry set. Enter with BX holding takadr. Local worker. getch proc near cmp [bx].takcnt,0 ; buffer empty? jg getch2 ; g = no cmp [bx].taktyp,0feh ; file? jne getch1 ; ne = no, a macro call takrd ; read another buffer cmp [bx].takcnt,0 ; end of file? jne getch2 ; ne = no getch1: stc ; e = yes, exit error ret getch2: push si push es mov es,[bx].takbuf ; segment of buffer mov si,[bx].takptr ; read a char from Take buffer mov al,es:[si] inc si mov [bx].takptr,si ; move buffer pointer dec [bx].takcnt ; decrease number of bytes remaining pop es pop si clc ; return carry clear ret getch endp ; IF [NOT] {< }| = | > | ALARM | COUNT | FAILURE | SUCCESS | INPATH filespec ; | ERRORLEVEL \number | EQUAL string string | EXIST filespec} command IFCMD PROC NEAR mov notflag,0 ; assume NOT keyword is absent ifcmd1: mov ah,cmkey ; parse keyword mov dx,offset iftable ; table of keywords xor bx,bx ; help is the table call comnd jnc ifcmd1a ; nc = success ret ; failure ifcmd1a:cmp bx,ifnot ; NOT keyword? jne ifcmd2 ; ne = no xor notflag,1 ; toggle not flag jmp short ifcmd1 ; and get next keyword ifcmd2: cmp bx,ifsuc ; IF SUCCESS? jne ifcmd4 ; ne = no cmp kstatus,kssuc ; do we have success? je ifcmd2a ; e = yes jmp ifcmdf ; ne = no, no jump ifcmd2a:jmp ifcmdp ; yes ifcmd4: cmp bx,iferr ; IF ERRORLEVEL? jne ifcmd5 ; ne = no jmp ifnum ; parse number to binary in line ifcmd5: cmp bx,ifext ; IF EXIST filespec? je ifcmd5a ; e = yes cmp bx,ifpath ; IF INPATH filespec? jne ifcmd6 ; ne = no ifcmd5a:mov ah,cmword ; read a filespec mov dx,offset rdbuf ; buffer for filespec push bx ; save command kind xor bx,bx call comnd pop bx jnc ifcmd5b ; nc = success ret ; failure ifcmd5b:mov ax,offset rdbuf ; isfile wants pointer in ds:ax cmp bx,ifpath ; INPATH? je ifcmd5c ; e = yes call isfile ; see if file exists jc ifcmdf ; c = no jmp ifcmdp ; yes, do following command ifcmd5c:call spath ; search path jc ifcmdf ; c = no such file jmp ifcmdp ; yes, do following command ifcmd6: cmp bx,iffail ; IF FAIL? jne ifcmd7 test kstatus,not (kssuc) ; check all bits jz ifcmdf ; z = not that condition, no jump jmp short ifcmdp ifcmd7: cmp bx,ifctr ; IF COUNT? jne ifcmd8 ; ne = no cmp taklev,0 ; in a Take file? je ifcmdf ; e = no, fail push bx mov bx,takadr ; current Take structure cmp [bx].takctr,0 ; exhausted count? je ifcmd7a ; e = yes, dec no more ye counter dec [bx].takctr ; dec COUNT if non-zero cmp [bx].takctr,0 ; exhausted now? je ifcmd7a ; e = yes pop bx jmp short ifcmdp ; COUNT > 0 at entry, execute command ifcmd7a:pop bx jmp short ifcmdf ; do not execute command ifcmd8: cmp bx,ifmdf ; IF DEF? jne ifcmd9 ; ne = no jmp ifmdef ; do further parsing below ifcmd9: cmp bx,ifalarm ; IF ALARM? jne ifcmd10 ; ne = no jmp ifalrm ; do further parsing below ifcmd10:cmp bx,ifequal ; IF EQUAL? jne ifcmd10a ; ne = no jmp ifequ ; do further parsing below ifcmd10a:cmp bx,iflgt ; IF LGT? jne ifcmd10b ; ne = no jmp ifequ ifcmd10b:cmp bx,ifllt ; IF LLT? jne ifcmd11 ; ne = no jmp ifequ ifcmd11:cmp bx,ifless ; IF <? je ifcmd12 ; e = yes cmp bx,ifsame ; IF =? je ifcmd12 cmp bx,ifmore ; IF > ? jne ifcmdf ; ne = no ifcmd12:jmp ifmath ; Jump points for worker routines ; failure ifcmdf: cmp notflag,0 ; need to apply not condition? jne ifcmdp2 ; ne = yes, take other exit ifcmdf2:mov ah,cmline ; fail, read and discard rest of line mov comand.cmblen,cmdblen mov bx,offset rdbuf mov dx,offset discard ; say not doing anything mov comand.cmper,1 ; don't expand variables at this time call comnd clc ; force success on discard of line ret ; success (pass) ifcmdp: cmp notflag,0 ; need to apply not condition? jne ifcmdf2 ; ne = yes, take other exit ifcmdp2:clc ; do command ret IFCMD ENDP ; Compare errlev against user number. Jump successfully if errlev >= number. ; Worker for IF [NOT] ERRORLEVEL number <command> ifnum proc near mov ah,cmword ; get following number mov dx,offset rdbuf+1 mov comand.cmblen,cmdblen mov rdbuf,'\' ; in case user forgets backslash mov word ptr rdbuf+1,0 ; clear buffer mov bx,offset ifnhlp ; help call comnd jnc ifnum1 ; nc = success ret ; failure ifnum1: mov si,offset rdbuf ; put text in compare buffer cmp rdbuf+1,'\' ; did user include backslash? jne ifnum2 ; ne = no inc si ; yes, skip our helpful backslash ifnum2: call katoi ; convert number to binary in ax jc ifnum4 ; c = failed to convert a number cmp errlev,al ; at or above this level? jae ifnum3 ; ae = yes, succeed jmp ifcmdf ; else fail ifnum3: jmp ifcmdp ; jump to main command Success exit ifnum4: mov dx,offset rdbuf+1 ; pointer to bad word mov tempd,dx ; remember starting place for text call strlen ; get its length add dx,cx ; skip over current word mov bx,dx mov byte ptr [bx],' ' ; space, chopped by parser inc bx ; new text goes here xor dx,dx ; help mov ah,cmline ; read rest of line mov comand.cmblen,cmdblen call comnd jnc ifnum4a ; nc = success ret ; failure ifnum4a:or ax,ax ; returned byte count jnz ifnum5 ; nz = got some mov byte ptr[bx-1],0 ; remove space separator from above ifnum5: mov ah,prstr mov dx,offset ifnmsg ; error message header int dos mov dx,offset rdbuf+1 ; start of user text call prtasz ; display asciiz string mov ah,prstr mov dx,offset ifnmsg2 ; trailer of message int dos jmp ifcmdf ; jump to main command Failure exit ifnum endp ; Process IF [NOT] DEF <macro name> <command> ifmdef proc near mov dx,offset rdbuf+2 ; point to work buffer mov bx,offset ifdfhlp ; help mov comand.cmblen,cmdblen mov ah,cmword ; get macro name mov comand.cmper,1 ; do not react to \%x call comnd jnc ifmde1 ; nc = success ret ; failure ifmde1: mov word ptr rdbuf,ax ; store length in buffer mov bx,offset mcctab+1 ; table of macro keywords mov tempd,0 ; tempd = current keyword cmp byte ptr [bx-1],0 ; any macros defined? je ifmde9 ; e = no, failure, exit now ; match table keyword and user word ifmde3: mov si,offset rdbuf ; pointer to user's cnt+name mov cx,[si] ; length of user's macro name add si,2 ; point to macro name cmp cx,[bx] ; compare length vs table keyword jne ifmde7 ; ne = not equal lengths, try another push si ; lengths match, how about spelling? push bx add bx,2 ; point at start of keyword ifmde4: mov ah,[bx] ; keyword char mov al,[si] ; new text char cmp al,'a' ; map lower case to upper jb ifmde5 cmp al,'z' ja ifmde5 sub al,'a'-'A' ifmde5: cmp al,ah ; test characters jne ifmde6 ; ne = no match inc si ; move to next char inc bx loop ifmde4 ; loop through entire length ifmde6: pop bx pop si jcxz ifmde10 ; z: cx = 0, found the name ; select next keyword ifmde7: inc tempd ; number of keyword to test next mov cx,tempd cmp cl,mcctab ; all done? Recall, tempd starts at 0 jae ifmde9 ; ae = yes, no match mov ax,[bx] ; cnt (keyword length from macro) add ax,4 ; skip over '$' and two byte value add bx,ax ; bx = start of next keyword slot jmp short ifmde3 ; do another comparison ifmde9: jmp ifcmdf ; jump to main command Failure exit ifmde10:jmp ifcmdp ; jump to main command Success exit ifmdef endp ; IF [not] ALARM hh:mm:ss command ifalrm proc near call chkkbd ; check keyboard for override test status,stat_cc ; Control-C? jz ifalr1 ; z = no stc ret ; yes, return failure now ifalr1: push word ptr timhms push word ptr timhms+2 ; save working timeouts mov ax,word ptr alrhms mov word ptr timhms,ax mov ax,word ptr alrhms+2 mov word ptr timhms+2,ax ; set alarm value call chktmo ; check for timeout pop word ptr timhms+2 ; restore working timeouts pop word ptr timhms test status,stat_tmo ; tod past user time (alarm sounded)? jnz ifalr4 ; nz = yes, succeed ; failure (not at alarm time yet) cmp notflag,0 ; need to apply NOT condition? jne ifalr5 ; ne = yes, take other exit ifalr3: mov ah,cmline ; fail, read and discard rest of line mov bx,offset rdbuf mov comand.cmblen,cmdblen xor dx,dx call comnd clc ; set command parse success ret ; success (at or past alarm time) ifalr4: cmp notflag,0 ; need to apply not condition? jne ifalr3 ; ne = yes, take other exit ifalr5: clc ; pass, do command ret ifalrm endp ; IF [NOT] {LLT, EQUAL, LGT} word word command ; Permits use of \number, {string}, @filespec ifequ proc near mov ltype,bl ; remember kind of lex test mov comand.cmblen,cmdblen mov ah,cmword ; get a word mov dx,offset rdbuf ; where to store mov rdbuf,0 ; clear first entry mov bx,offset ifehlp1 ; help call comnd ; ignore parse error if no text mov si,offset rdbuf ; start of line mov di,si ; convert to the same place call cnvlin ; convert \numbers to binary jc ifequ9 ; carry set means error jcxz ifequ9 ; z = empty word mov tempd,cx add si,cx inc si ; skip null terminator mov temptr,si ; place to start second part mov dx,si mov word ptr[si],0 ; clear second part mov ah,cmword ; get a word of text mov bx,offset ifehlp2 ; help mov comand.cmblen,cmdblen call comnd ; ignore parse error if no text mov si,temptr ; start of second line mov di,si ; convert to the same place call cnvlin ; convert \numbers to binary jc ifequ9 ; c = failure jcxz ifequ9 ; z = empty word cmp tempd,cx ; first longer than second? jae ifequ3 ; ae = yes xchg tempd,cx ; use length of shorter word ifequ3: inc cx ; include null terminator in count mov si,offset rdbuf ; first word mov di,temptr ; second word push es mov ax,ds mov es,ax cld repe cmpsb ; compare while equal pop es jb ifequ6 ; exited on before condition ja ifequ7 ; exited on above condition cmp ltype,ifequal ; wanted EQUAL condition? jne ifequ9 ; ne = no, fail jmp ifcmdp ; else success ifequ6: cmp ltype,ifllt ; LLT test? jne ifequ9 ; ne = no, failed jmp ifcmdp ; do IF cmd success ifequ7: cmp ltype,iflgt ; LGT test? jne ifequ9 ; ne = no, failed jmp ifcmdp ; do IF cmd success ifequ9: jmp ifcmdf ; do IF cmd failure ifequ endp ; Worker for IF [NOT] < = > var var <command> ; var is ARGC, COUNT, ERRORLEVEL, VERSION, or a 16 bit number ifmath proc near mov tempa,bl ; save kind of math test here mov temp,0 ; place to store first value mov tempd,0 ; count times around this loop ifmath1:mov dx,offset rdbuf+1 mov rdbuf,'\' ; in case user forgets backslash mov word ptr rdbuf+1,0 ; clear buffer mov bx,offset ifmhlp ; help mov comand.cmblen,cmdblen mov ah,cmword ; get following number call comnd jnc ifmath2 ; nc = success ret ; failure ifmath2:mov si,offset rdbuf+1 ; put text in compare buffer mov ax,[si] ; get first two user chars or ax,2020h ; lowercase both bytes cmp ax,'ra' ; ARGC? jne ifmath3 ; ne = no xor ax,ax cmp taklev,0 ; in a Take/macro? je ifmath8 ; e = no, report ARGC as 0 mov bx,takadr ; current Take structure mov ax,[bx].takargc ; get argument count jmp short ifmath8 ifmath3:cmp ax,'re' ; ERRORLEVEL? jne ifmath4 ; ne = no mov al,errlev ; get errorlevel xor ah,ah jmp short ifmath8 ifmath4:cmp ax,'oc' ; COUNT? jne ifmath5 ; ne = no xor ax,ax cmp taklev,0 ; in a Take/macro? je ifmath8 ; e = no, report COUNT as 0 mov bx,takadr ; current Take structure mov ax,[bx].takctr ; get COUNT jmp short ifmath8 ifmath5:cmp ax,'ev' ; VERSION? jne ifmath5a ; ne = no mov ax,version ; get version such as 300 jmp short ifmath8 ifmath5a:cmp ax,'ek' ; KEYBOARD? jne ifmath6 ; ne = no mov ax,keyboard ; get 88 or 101 for keys on keyboard jmp short ifmath8 ifmath6:cmp rdbuf+1,'\' ; did user include backslash? je ifmath7 ; e = yes dec si ; no, employ our helpful backslash ifmath7:call katoi ; convert number to binary in ax jc ifmathb ; c = failed to convert a number ifmath8:cmp tempd,0 ; gotten second value yet? ja ifmath9 ; a = yes, it is in ax mov temp,ax ; save first value inc tempd ; say we have been here jmp ifmath1 ; do second argument ifmath9:mov bl,tempa ; kind of math test cmp bl,ifless ; "<"? jne ifmath10 ; ne = no cmp temp,ax ; val1 < val2? jb ifmathp ; b = pass jmp short ifmathf ; fail ifmath10:cmp bl,ifsame ; "="? jne ifmath11 ; ne = no cmp temp,ax ; val1 = val2? je ifmathp ; e = yes, pass jmp short ifmathf ; fail ifmath11:cmp temp,ax ; val2 > val1? ja ifmathp ; a = yes, pass ifmathf:jmp ifcmdf ; else fail ifmathp:jmp ifcmdp ; jump to main command Success exit ifmathb:jmp ifnum4 ; do common error complaint ifmath endp ; DECREMENT/INCREMENT variable size (default size 1) ; Permits variable to be \%<char> or a macro name. Non-negative results. decvar proc near mov temp,-1 ; marker to say dec jmp short incvar1 decvar endp incvar proc near mov temp,1 ; marker to say inc incvar1: mov kstatus,ksgen ; general command failure mov ah,cmword ; Common code mov word ptr rdbuf,0 ; entry count, empty mov dx,offset rdbuf+2 ; reserve word 0 for entry count mov bx,offset chgvarhlp mov comand.cmper,1 ; don't react to \%x variables call comnd jnc incvar2 ; nc = success ret ; failure incvar2:or ax,ax ; necessary macro name? jnz incvar3 ; nz = yes incvar2a:stc ; no, fail ret incvar3:mov word ptr rdbuf,ax ; save length of macro name mov si,offset mcctab ; table of macro names cld lodsb mov cl,al ; number of macro entries xor ch,ch jcxz incvar2a ; z = none ; find variable incvar4:push cx ; save loop counter lodsw ; length of macro name to ax mov cx,word ptr rdbuf ; length of user's string cmp ax,cx ; variable name same as user spec? jne incvar6 ; ne = no, no match push ax push si ; save these around match test mov di,offset rdbuf+2 ; user's string incvar5:mov ah,[di] inc di lodsb ; al = mac name char, ah = user char and ax,not 2020h ; clear bits (uppercase chars) cmp ah,al ; same? loope incvar5 ; while equal, do more pop si ; restore regs pop ax jne incvar6 ; ne = no match pop cx ; remove loop counter jmp short incvar7 ; e = match incvar6:add si,ax ; point to next name, add name length add si,2 ; and string pointer pop cx ; recover loop counter loop incvar4 ; one less macro to examine xor ax,ax mov temp,ax ; indicate failure jmp incvar13 ; go do command confirmation incvar7:mov ax,[si-2] ; get length of variable string add si,ax ; point to segment of definition mov si,[si] ; seg of definition mov word ptr rdbuf+2,si ; preserve seg for later storage push es mov es,si mov cx,es:[0] ; length of definition cmp cx,9 ; "\x{65384}" is max length ja incvar10 ; a = too large to qualify mov di,offset rdbuf+4 ; copy string to regular data segment mov si,2 ; skip over string count word mov al,es:[si] ; get leading byte cmp al,'\' ; escaped number je incvar9 ; e = yes mov byte ptr [di],'\' ; insert escape inc di incvar9:mov al,es:[si] ; copy string to regular data segment mov [di],al inc si inc di loop incvar9 mov byte ptr [di],0 ; asciiz mov si,offset rdbuf+4 call katoi ; convert var value to binary in ax jc incvar10 ; c = failed mov word ptr rdbuf,ax ; save value here, seg in rdbuf+2 pop es jmp short incvar12 ; now get step size, if any incvar10:pop es xor ax,ax mov temp,ax ; setup failure jmp short incvar13 ; do command confirmation incvar12:mov ah,cmword ; get step size, if any mov comand.cmblen,7 ; length of step size mov dx,offset rdbuf+6 ; where to put string mov bx,offset ssizehlp call comnd jnc incvar13 ret incvar13:push ax ; save step size string length mov ah,cmeol call comnd pop ax jnc incvar14 ; nc = success ret ; now convert step size, if any incvar14:or ax,ax ; is length zero? jnz incvar15 ; nz = no, convert number to binary inc ax ; set default inc/dec to 1 jmp incvar17 ; go process new value incvar15:mov si,offset rdbuf+6 ; step size string cmp byte ptr [si],'\' ; has "\"? je incvar16 ; e = yes dec si mov byte ptr [si],'\' ; insert one incvar16:call katoi ; ds:si to number to ax jnc incvar17 ; nc = a number ret ; fail ; step size is in ax incvar17:mov cx,word ptr rdbuf ; current value of variable cmp temp,0 ; inc or dec? jg incvar19 ; g = increment jl incvar18 ; l = decrement stc ; else fail ret incvar18:cmp ax,cx ; if would subtract too much jbe incvar18a ; be = ok stc ; a = would go below zero, fail ret incvar18a:neg ax ; change increment to negative add ax,cx ; add current value jc incvar20 ; c = ok stc ret ; fail incvar19:add ax,cx ; increment jnc incvar20 ret ; carry means fail incvar20:mov di,offset rdbuf+4 ; place to store string call dec2di ; binary to ascii decimal in ds:di mov si,offset rdbuf+4 sub di,si ; new string length mov cx,di cld push es mov ax,word ptr rdbuf+2 ; get segment of variable mov es,ax mov di,2 mov es:[di-2],cx ; store new count word rep movsb ; copy string to variable's seg pop es mov kstatus,kssuc ; say success clc ret incvar endp ; SET ALARM <time, sec from now or HH:MM:SS> SETALRM PROC NEAR mov dx,offset line ; point to work buffer mov word ptr line,0 mov word ptr line+2,0 mov bx,offset alrmhlp ; help mov ah,cmword ; get macro name call comnd jc setal1 ; c = failure mov ah,cmeol ; get a confirm call comnd jc setal1 ; c = failure push word ptr timhms push word ptr timhms+2 ; save working timeouts mov si,offset line ; source pointer call inptim ; get the timeout time, sets si mov ax,word ptr timhms ; save time in alarm area mov word ptr alrhms,ax mov ax,word ptr timhms+2 mov word ptr alrhms+2,ax pop word ptr timhms+2 ; restore working timeouts pop word ptr timhms clc setal1: ret SETALRM ENDP ; REINPUT <timeout> <match text> ; Reread material in serial port buffer, seeking a match with user's text ; pattern. If user's pattern is longer than material in buffer then read ; additional characters from the serial port. Use SCINP to do the main work. SCREINP PROC NEAR mov reinflg,1 ; say doing REINPUT, not INPUT jmp short input10 SCREINP ENDP ; Input from port command, match input with text pattern ; Input [timeout] text ; SCINP PROC NEAR mov reinflg,0 ; say doing INPUT, not REINPUT jmp short input10 input10:mov kstatus,kssuc mov ah,cmline ; get a whole line of asciiz text mov bx,offset line ; place to put text mov dx,offset inphlp ; help message call comnd ; get the pattern text jnc input11 ; nothing, complain ret ; failure input11:mov ah,cmeol call comnd jnc input12 ret input12:cmp reinflg,0 ; Input command? jne input1 ; ne = no, Reinput cmp taklev,0 ; are we in a Take file? je input0 ; e = no, display linefeed cmp flags.takflg,0 ; are Take commands being echoed? je input1 ; e = no, skip display input0: cmp script.inecho,0 ; Input echo off? je input1 ; e = yes mov al,lf ; next line call scdisp ; display the char input1: call serini ; initialize the system's serial port jc input1a ; c = failure mov status,stat_unk ; clear status flag mov si,offset line ; source pointer call inptim ; get the timeout time, sets si jnc input1b ; nc = legal time value or none input1a:jmp input5 ; else fail on error input1b:mov di,offset line ; put text in compare buffer call cnvlin ; convert \numbers in buf line mov inplen,cx ; cx = number of bytes in final string mov parmsk,0ffh ; parity mask, assume 8 bit data mov di,portval cmp [di].parflg,parnon ; parity is none? je input1c ; e = none mov parmsk,07fh ; else strip parity (8th) bit input1c:mov di,offset line mov temptr,di ; pointer to pattern char mov temptr2,di ; and we need pointer to end of string add temptr2,cx ; offset of end of string ; setup reinput read pointer & count mov ax,bufwtptr ; where next new char goes mov bufpkptr,ax ; set peek-read pointer at oldest char mov ax,scpbuflen ; length of the buffer mov bufpkcnt,ax ; always look back one full buffer ; see if a pattern needs matching cmp inplen,0 ; empty pattern? (cnvlin sets cx=cnt) jne input4 ; ne = not empty cmp reinflg,0 ; Input command? je input3 ; e = yes, read and discard chars jmp input5 ; reinput, just exit timeout ; empty. read, display, and discard input3: call chkkbd ; check keyboard test status,stat_cc ; did user type control-c? jnz input3b ; nz = yes, quit test status,stat_cr ; did user type cr? [js] jz input3a ; z = no or status,stat_tmo ; force timeout status too jmp short input5 ; nz = yes, return timeout failure input3a:call chktmo ; check timeout test status,stat_tmo input3b:jnz input5 ; nz = timed out, quit call bufread ; read from serial port buffer into al jmp short input3 ; loop until timeout, exit timeout ; start main read and compare loop input4: mov di,temptr ; pointer to current pattern char cmp di,temptr2 ; at end of pattern? jae inputx ; ae = yes, return success call chkkbd ; check keyboard test status,stat_cc ; did user type Control-C? jnz input5 ; nz = yes, quit test status,stat_cr ; did user type cr? [js] jz input4a ; z = no or status,stat_tmo ; force timeout status too jmp short input5 ; nz = yes, return success [js] input4a:test status,stat_tmo+stat_ok ; user override/timeout on last read jnz input5 ; nz = timed out, quit cmp reinflg,0 ; Input command? jne input4b ; ne = no, a reinput cmd call bufread ; read from serial port buffer into al jc input4 ; c = nothing there, keep looking jmp short input4c ; analyze character input4b:call peekbuf ; reinput: peek-read from buffer jnc input4c ; nc = got a character into al test status,stat_tmo ; timeout (or examined all chars)? jz input4 ; z = no, keep trying jnz input5 ; nz = timeout getting a character ; got a char from buffer/port input4c:cmp al,'a' ; candidate for case conversion? [js] jb input4d ; b = no [js] cmp al,'z' ; in lower case set? [js] ja input4d ; a = no [js] and al,script.incasv ; apply case conversion mask input4d:mov di,temptr mov ah,byte ptr [di] ; get current pattern char again call matchr ; al=rcvd, ah=pattern, do they match? jc inpm ; c = no match, try substring inc temptr ; matched, point to next pattern char jmp short input4 input5: or errlev,ksrecv ; set RECEIVE failure condition or fsta.xstatus,ksrecv ; set status or kstatus,ksrecv cmp reinflg,0 ; Input command? jne input6 ; ne = no jmp squit ; exit failure: timeout or Control-C input6: jmp squit1 ; skip timeout message, if any inputx: clc ; return success ret ; See if a trailing-subset of the matched chars + new port char can match ; the beginning part of the pattern. That is, if we were to simply "forget" ; the oldest of the matched chars and slide left the apparent port string ; then could we eventually find a match? Example: "Input 10 memema" ; gives the pattern of "memema"; suppose the received chars were "mememema". ; Forgetting one left-most rcv'd char at a time (two in this case) finally ; yields a match, from which we should continue to compare fresh port chars ; with successive pattern chars until either they match through all pattern ; chars or we encounter another break. If there is a later break, repeat this ; algorithm. ; Since we really have only the latest char from the port then pointers to ; the matched pattern chars are used to mimic the earlier received chars: ; they must have been identical to produce a match to date. The quick way ; to "forget" oldest received chars is to scan backward through the matched ; pattern chars looking for the current port char; if the first such find does ; not yield a matching substring then look back further. ; no or partial match then break ; di = temptr = pattern break char ; al = port char causing break ; di - offset line = # chars matched thus far ; avoid cpu-brand side effects with "repne scasb" inpm: mov tempa,al ; save port char here inpm1: mov tempd,di ; pattern break loc, where matching failed mov cx,di ; char at di does not match current port char sub cx,offset line ; compute count of matched bytes jcxz inpm4 ; z = 0 = mismatch on the initial pattern char mov al,tempa ; port char to find (in case we looped here) inpm2: dec di ; back up one pattern char mov ah,byte ptr [di]; current pattern character to consider call matchr ; is port char = earlier pattern char? [js] jnc inpm3 ; nc = equal values, go construct substring loop inpm2 ; do cx times, max. (length of match to date) jmp short inpm4 ; get here when there are no matches [js] inpm3: mov bx,tempd ; get last break location sub bx,di ; displacement = break - new find of port char mov tempd,di ; remember new location of a port-like char ; cx has number of chars in test substring dec cx ; matched one char already [jrs] jcxz inpm3a ; is there anything left? [jrs] call matstr ; does this substring match the pattern? jc inpm1 ; c = no match, try making substring smaller inpm3a: mov di,tempd ; sub-string matched. Use this shorter match mov temptr,di ; set di for exit (matstr messes up di) inc temptr ; matched, point to next pattern char jmp input4 ; continue with fresh port info inpm4: mov temptr,offset line; complete failure, restart scanning jmp input4 ; get something from the port ; worker for SCINP ; compare strings. One starts at offset line, the other starts bx bytes later. ; cx = # chars to compare. Return carry clear if match, else carry set. matstr: mov si,offset line ; start of pattern string matstr1:mov ah,byte ptr [si] ; pattern char mov al,byte ptr [si+bx] ; "old port char" (same as pattern char) call matchr ; check match of these two characters jc matstr2 ; c = no match (exit with carry flag set) inc si ; match, consider next pair loop matstr1 ; consider rest of substring (cx is counter) clc ; clear c bit (substrings do match) matstr2:ret ; preserves flags (c set = no match) ; worker for SCINP ; compare single characters, one in ah and the other in al. Allow the 0ffh ; wild card to match CR and LF individually. Return carry clear if match, ; or carry set if they do not match. Registers preserved. matchr: cmp ah,al ; do these match? je matchr6 ; e = yes cmp ah,0ffh ; the match cr/lf indicator? je matchr2 ; e = yes cmp al,0ffh ; the match cr/lf indicator? jne matchr5 ; ne = no match at all. matchr2:push ax ; save both chars again and ah,al ; make a common byte for testing cmp ah,cr je matchr4 ; e = cr matches 0ffh cmp ah,lf je matchr4 ; e = lf matches 0ffh pop ax ; recover chars matchr5:stc ; set carry (no match) ret matchr4:pop ax ; recover chars matchr6:clc ; clear carry (match) ret SCINP ENDP ; Pause for the indicated number of milliseconds, do not access comms channel SCMPAUSE PROC NEAR mov kstatus,kssuc mov ah,cmword ; get a word (number) mov dx,offset line+1 ; where to store it mov line,'\' ; optional number escape mov line+1,0 ; terminate line incase no text mov bx,offset mphlp ; help msg call comnd jnc scmpau1 ; nc = success ret scmpau1:mov si,offset line ; put text in compare buffer cmp line+1,'\' ; did user include backslash? jne scmpau2 ; ne = no inc si ; yes, skip our helpful backslash scmpau2:call katoi ; convert number to binary in ax jc scmpau3 ; c = failed to convert a number call pcwait ; delay number of millisec in AX clc ret scmpau3:mov ah,prstr mov dx,offset mpbad ; complain about bad number int dos mov kstatus,ksgen ; command status, failure stc ret SCMPAUSE ENDP ; Pause for the specified number of seconds or until a time of day ; Pause [seconds or hh:mm:ss] ; SCPAU PROC NEAR mov kstatus,kssuc mov ah,cmword ; get a word (number) mov dx,offset line ; where to store it mov byte ptr line,0 ; terminate line incase no text mov bx,offset ptshlp ; help msg call comnd jc scpau1 ; c = failure mov si,offset line ; source pointer call inptim ; parse pause time (or force default) jc scpau1 ; c = bad time value mov wtemp,0 ; no modem status to detect jmp swait4 ; finish in common code scpau1: ret ; return command failure SCPAU ENDP ; ; Wait for the indicated signal for the specified number of seconds or tod ; WAIT [seconds] \signal where \signal is \cd, \dsr, \ri modem status lines. ; Use INPUT-TIMEOUT ACTION for failures. ; SCWAIT PROC NEAR mov kstatus,kssuc mov ah,cmword ; get a word (number) mov dx,offset line ; where to store it mov byte ptr line,0 ; terminate line in case no text mov bx,offset ptshlp ; time help msg call comnd jnc swait0 ; nc = success ret swait0: mov wtemp,0 ; clear modem status test byte mov si,offset line ; source pointer push ax ; save length count call inptim ; parse pause time (or force default) pop ax jnc swait0a ; nc = good time value ret swait0a:cmp si,offset line ; was a number parsed? je swait1c ; e = no, reparse as modem signal swait1: mov ah,cmword ; get optional modem signal word(s) mov dx,offset line mov bx,offset wthlp ; modem signal help call comnd jnc swait1c ; nc = success ret swait1c:mov si,offset line mov cx,ax ; returned byte count or cx,cx ; number of chars to examine jle swait4 ; le = none cld swait1d:lodsb ; get a character dec cx ; reduce count remaining cmp al,'\' ; backslash signal introducer? je swait1d ; e = yes, skip it cmp cx,1 ; at least two chars in signal? jl swait3a ; l = no, bad syntax mov ax,[si-1] ; get first two characters or ax,2020h ; upper case to lower, two chars cmp ax,'dc' ; carrier detect? jne swait2 ; ne = no, try next signal or wtemp,modcd ; look for the CD bit inc si ; skip this field and separator dec cx ; two less chars left in the line jmp short swait1 ; continue the scan swait2: cmp ax,'sd' ; data set ready? jne swait3 ; ne = no mov al,[si+1] ; third letter or al,20h ; to lower case cmp al,'r' ; r for dsr? jne swait3b ; ne = no or wtemp,moddsr ; look for the DSR bit add si,2 ; skip this field and separator sub cx,2 ; three less chars left in the line jmp short swait1 swait3: cmp ax,'tc' ; clear to send? jne swait3a ; ne = no mov al,[si+1] ; third letter or al,20h ; to lower case cmp al,'s' ; r for dsr? jne swait3b ; ne = no or wtemp,modcts ; look for the CTS bit add si,2 ; skip this field and separator sub cx,2 ; three less chars left in the line jmp short swait1 ; continue the scan swait3a:cmp ax,'ir' ; ring indicator jne swait3b ; ne = no, try next signal or wtemp,modri ; look for the RI bit inc si ; skip this field and separator dec cx ; two less chars left in the line jmp short swait1 ; continue the scan swait3b:or al,al ; null terminator? je swait4 ; e = yes, no more text mov ah,prstr mov dx,offset wtbad ; say bad syntax int dos or errlev,ksuser ; set user intervention error condx or fsta.xstatus,ksuser ; set status or kstatus,ksuser stc ; failure ret ; SWAIT4 is used by PAUSE command SWAIT4: mov ah,cmeol ; get command confirmation call comnd jnc swait4a ret ; c set is failure swait4a:cmp taklev,0 ; are we in a Take file je swait5 ; e = no, print linefeed cmp flags.takflg,0 ; are commands being echoed je swait6 ; e = no, skip this swait5: cmp script.inecho,0 ; Input echoing off? je swait6 ; e = yes mov al,lf ; next line call scdisp ; display the char swait6: call serini ; initialize the system's serial port jc swait9 ; c = failure mov status,stat_unk ; clear status flag push si mov parmsk,0ffh ; parity mask, assume 8 bit data mov si,portval cmp [si].parflg,parnon ; parity is none? pop si je swait7 ; e = none mov parmsk,07fh ; else strip parity (8th) bit swait7: cmp wtemp,0 ; anything to be tested? je swait8 ; e = no, just do the wait part call getmodem ; modem handshake status to AL and al,wtemp ; keep only bits to be tested cmp al,wtemp ; check selected status bits jne swait8 ; ne = not all selected bits match clc ; all match. take successful exit ret swait8: call chkport ; get and show any new port char call chkkbd ; check keyboard test status,stat_cc ; control-c? jnz swait9 ; nz = yes, quit call chktmo ; check tod for timeout test status,stat_tmo+stat_ok ; timeout or user override? jz swait7 ; z = no, continue to wait cmp wtemp,0 ; were we waiting on anything? jne swait9 ; ne = yes, timeout = failure clc ; else timeout = success ret swait9: or errlev,ksuser ; set user intervention error condx or fsta.xstatus,ksuser ; set status or kstatus,ksuser jmp squit ; take error exit SCWAIT ENDP ; Output line of text to port, detect \b and \B as commands to send a Break ; and \l and \L as a Long Break on the serial port line. ; Output text, display up to 100 received chars while doing so. SCOUT PROC NEAR mov kstatus,kssuc mov ah,cmline ; get a whole line of asciiz text mov bx,offset line ; store text here mov dx,offset outhlp ; help message call comnd jnc outp0d ; nc = success ret ; failure outp0d: cmp apctrap,0 ; disable from APC je outp0e ; e = no stc ; fail ret outp0e: cmp taklev,0 ; is this being done in a Take file? je outpu0 ; e = no, display linefeed cmp flags.takflg,0 ; are commands being echoed? je outp0a ; e = no, skip the display outpu0: cmp script.inecho,0 ; Input echoing off? je outp0a ; e = yes mov al,lf ; next line call scdisp ; display the char outp0a: mov al,spause ; wait three millisec or more add al,3 xor ah,ah call pcwait ; breathing space for HDX systems call serini ; initialize the system's serial port jnc outp0c ; nc = success or errlev,kssend ; set SEND failure condition or fsta.xstatus,kssend ; set status or kstatus,kssend jmp squit outp0c: mov status,stat_unk ; clear status flag mov parmsk,0ffh ; parity mask, assume 8 bit data mov si,portval cmp [si].parflg,parnon ; parity is none? je outp0b ; e = none mov parmsk,07fh ; else strip parity (8th) bit outp0b: mov si,portval ; serial port structure mov bl,[si].ecoflg ; Get the local echo flag mov lecho,bl ; our copy mov si,offset line ; get start of line mov di,offset line ; put results in the same place mov ah,script.incasv ; save current case state push ax mov script.incasv,0ffh ; say no case conversion call cnvlin ; convert \numbers to binary pop ax mov script.incasv,ah ; recover case state jnc outpu1 ; nc = no error ret ; return on error outpu1: mov temptr,offset line ; save pointer here mov tempd,cx ; save byte count here mov ttyact,1 ; say interactive style output outpu2: cmp tempd,0 ; are we done? jg outpu2a ; g = not done yet mov ttyact,0 ; reset interactive output flag clc ; return success ret outpu2a:mov si,temptr ; recover pointer cld lodsb ; get the character dec tempd ; one less char to send mov temptr,si ; save position on line mov tempa,al ; save char here for outchr mov retry,0 ; number of output retries cmp al,5ch ; backslash? jne outpu4d ; ne = no mov al,[si] and al,not 20h ; to upper case cmp al,'B' ; "\B" for BREAK? jne outpu4l ; ne = no outpu4c:inc temptr ; move scan ptr beyond "\b" dec tempd call sendbr ; call msx send-a-break procedure jmp short outpu5 ; resume beyond echoing outpu4l:cmp al,'L' ; "\L" for Long BREAK? jne outpu4d ; ne = no inc temptr dec tempd call sendbl ; send a Long BREAK jmp short outpu5 ; resume beyond echoing outpu4d:inc retry ; count output attempts cmp retry,maxtry ; too many retries? jle outpu4g ; le = no or errlev,kssend ; set SEND failure condition or fsta.xstatus,kssend ; set status or kstatus,kssend jmp squit ; return failure outpu4g: mov ax,outpace ; millisecs pacing delay inc ax ; at least 1 ms call pcwait mov ah,tempa ; outchr gets fed from ah call outchr ; send the character to the port jc outpu4d ; failure to send char cmp lecho,0 ; is Local echo active? je outpu5 ; e = no mov al,tempa ; test flags.capflg,logses ; is capturing active? jz outp4b ; z = no push ax ; save char call cptchr ; give it captured character pop ax ; restore character and keep going outp4b: cmp script.inecho,0 ; Input echo off? je outpu5 ; e = yes call scdisp ; echo character to the screen ; outpu5: mov tempa,100+1 ; wait for max 100 chars in/out [dan] outpu5a:mov cx,10 ; reset retry counter outpu5b:push cx call chkkbd ; check keyboard for interruption pop cx test status,stat_cc ; control c interrupt? jnz outpu6 ; nz = yes, quit now cmp script.inecho,0 ; Input echo off? je outpu5c ; e = yes, skip port reading/display dec tempa ; reached maximum chars in yet? [dan] jz outpu5c ; z = yes, send character anyway [dan] push cx call chkport ; check for char at serial port pop cx test status,stat_ok ; and put any in buffer jnz outpu5a ; nz = have a char, look for another mov ax,1 ; wait 1 millisec between rereads push cx ; protect counter call pcwait pop cx dec cx ; count down retries jge outpu5b ; ge = keep trying outpu5c:jmp outpu2 ; no more input, resume command outpu6: or errlev,kssend ; set SEND failure condition or fsta.xstatus,kssend ; set status or kstatus,kssend mov ttyact,0 ; reset interactive output flag jmp squit ; quit on control c SCOUT ENDP ; Raw file transfer to host (strips linefeeds) ; Transmit filespec [prompt] ; Optional prompt is the single char expected from the host to ACK each line. ; Default prompt is a script.xmitpmt (linefeed) or a carriage return from us. ; SCXMIT PROC NEAR mov kstatus,kssuc mov ah,cmword ; get a filename, asciiz mov dx,offset line ; where to store it mov bx,offset xmthlp ; help message call comnd jnc xmit0c ; nc = success ret ; failure xmit0c: mov ah,cmword ; get a prompt string, asciiz mov dx,offset line+81 ; where to keep it (end of "line") mov bx,offset pmthlp ; Help in case user types "?". call comnd jnc xmit0d ; nc = success ret ; failure xmit0d: mov line+80,al ; length of user's string mov ah,cmeol ; confirm call comnd jnc xmit0e ret xmit0e: cmp line,0 ; filename given? je xmit0a ; e = no mov si,offset line+81 ; convert possible numeric prompt cmp byte ptr [si-1],0 ; anything given? jz xmit0 ; z = no, use default call katoi ; convert number to binary, if number jnc xmit0b ; nc = got number mov al,line+81 ; get ascii char from user's prompt xmit0b: mov script.xmitpmt,al ; set prompt xmit0: mov dx,offset line ; point to filename mov ah,open2 ; DOS 2 open file xor al,al ; open for reading int dos mov fhandle,ax ; store file handle here mov temp,0 ; counts chars/line jnc xmit1 ; nc = successful opening xmit0a: mov ah,prstr ; give file not found error message mov dx,offset xfrfnf int dos or errlev,kssend ; set SEND failure condition or fsta.xstatus,kssend ; set status or kstatus,kssend jmp squit ; exit failure xmitx: mov ah,prstr ; error during transfer mov dx,offset xfrrer int dos xmitx2: mov bx,fhandle ; file handle mov ah,close2 ; close file int dos call bufclear ; clear script buffer call clrbuf ; clear local serial port buffer or errlev,kssend ; set SEND failure condition or fsta.xstatus,kssend ; set status or kstatus,kssend jmp squit ; exit failure ; xmity: mov bx,fhandle ; file handle mov ah,close2 ; close file int dos call bufclear ; clear buffers call clrbuf clc ; and return success ret xmit1: call serini ; initialize serial port jnc xmit1b ; nc = success or errlev,kssend ; set SEND failure condition or fsta.xstatus,kssend ; set status or kstatus,kssend jmp squit xmit1b: call bufclear ; clear script input buffer call clrbuf ; clear serial port buffer mov status,stat_unk ; clear status flag mov parmsk,0ffh ; parity mask, assume 8 bit data mov si,portval cmp [si].parflg,parnon ; parity is none? je xmit1a ; e = none mov parmsk,07fh ; else strip parity (8th) bit xmit1a: mov bl,[si].ecoflg ; get the local echo flag mov lecho,bl ; our copy mov dx,offset crlf ; display cr/lf mov ah,prstr int dos xmit2: mov dx,offset line ; buffer to read into mov cx,linelen ; # of bytes to read mov ah,readf2 ; read bytes from file mov bx,fhandle ; file handle is stored here int dos jnc xmit2a ; nc = success jmp xmitx ; exit failure xmit2a: mov cx,ax ; number of bytes read jcxz xmity ; z = none, end of file mov si,offset line ; buffer for file reads cld xmit3: lodsb ; get a byte cmp al,ctlz ; is this a Control-Z? jne xmit3a ; ne = no cmp flags.eofcz,0 ; ignore Control-Z as EOF? je xmit3a ; e = yes jmp xmity ; ne = no, we are at EOF xmit3a: push si ; save position on line push cx ; and byte count cmp al,cr ; CR, end of line? jne xmit3b ; ne = no cmp temp,0 ; chars sent in this line, any? ja xmit3c ; a = sent some cmp script.xmitfill,0 ; fill empty lines? je xmit3c ; e = no, send the cr mov al,script.xmitfill ; empty line fill char pop cx pop si dec si ; backup read pointer to CR again inc cx ; count filler as line information push si push cx jmp short xmit3c xmit3b: cmp al,lf ; line feed? jne xmit3c ; ne = no cmp script.xmitlf,0 ; send LF's? je xmit7 ; e = no, don't send it mov temp,-1 ; -1 so inc returns 0 after send xmit3c: push ax ; save char around outchr call mov retry,0 ; clear retry counter xmit4f: pop ax ; recover saved char push ax ; and save it again mov ah,al ; outchr wants char in ah inc retry ; count number of attempts cmp retry,maxtry ; too many retries? jle xmit4g ; le = no or status,stat_cc ; simulate control-c abort pop ax ; clean stack xor al,al ; clear char jmp short xmita ; and abort transfer xmit4g: call outchr ; send the character to the port inc temp ; count chars sent in this line jc xmit4f ; c failed, try again xmit4h: pop ax ; recover saved char cmp lecho,0 ; is local echoing active? je xmit5 ; e = no test flags.capflg,logses ; capturing active? jz xmit4a ; z = no call cptchr ; give it the character just sent xmit4a: call scdisp ; display char on screen xmit5: cmp al,cr ; did we send a carriage return? je xmit8 ; e = yes, time to check keyboard xmit7: pop cx pop si dec cx or cx,cx jle xmit7a ; le = finished this line jmp xmit3 ; finish this buffer full xmit7a: jmp xmit2 ; read next buffer xmit8: test status,stat_cc ; Control-C seen? jnz xmita ; nz = yes mov temp,0 ; say starting new char/line count call chkkbd ; check keyboard (returns char in al) test status,stat_ok ; have a char? jnz xmita ; nz = yes cmp script.xmitpmt,0 ; is prompt char a null? jne xmit8b ; ne = no call bufread ; check for char from serial port buf jnc xmit8 ; nc = a char, read til none jmp short xmit8c ; continue transfer xmit8b: call bufread ; check for char from serial port buf jc xmit8 ; c = none cmp al,script.xmitpmt ; is port char the ack? jne xmit8 ; ne = no, just ignore the char xmit8c: mov ax,script.xmitpause ; get millisecs to pause or ax,ax ; any time? jz xmit7 ; z = none call pcwait ; wait this long jmp short xmit7 ; yes, continue transfer xmita: test status,stat_cc ; Control-C? jnz xmitc ; nz = yes test status,stat_cr ; a local ack? jz xmit8 ; z = no, ignore local char mov dx,offset crlf ; display cr/lf mov ah,prstr int dos jmp xmit8c ; continue transfer xmitc: pop cx ; Control-C, clear stack pop si ; ... mov dx,offset xfrcan ; say canceling transfer mov ah,prstr int dos mov flags.cxzflg,0 ; clear Control-C flag jmp xmitx2 ; ctrl-c, quit SCXMIT ENDP ;;;;;;;;;;;;;;;;;; local support procedures ;;;;;;;;;; ; ;worker: copy line from si to di, converting \nnn strings to single chars ; returns carry set if error, else carry clear. Detects leading at-sign ; as an indicator to read command file for one line of text; command files ; may be nested to a depth of 100. ; Items of the form \chars which are not numbers are copied verbatium ; to the output string (ex: \a is copied as \a). The string is first trimmed ; of trailing spaces, then the possible curly brace delimiter pair is ; removed, and finally \numbers are converted to binary. [jrd] cnvlin proc near push tempd push es push si ; source ptr push di ; destination ptr push ds pop es ; use data segment for es:di mov tempd,0 ; count indirection depth cnvln0: cmp tempd,100 ; limit to 100 deep jbe cnvln0a ; be = not too deep yet jmp cnvln8 ; too deep, quit cnvln0a:cld xor cx,cx ; initialize returned byte count lodsb ; get the first character cmp al,40h ; at-sign indirection? je cnvln5 ; e = yes, open the file dec si ; no, push back char just read call cnvstr ; convert string's curly braces cnvln1: xor ah,ah ; clear high byte of number call katoi ; get a char into al, convert number jnc cnvln4 ; nc = binary number converted cmp al,0ffh ; cr/lf wild card? je cnvln4 ; e = yes, store it or al,al ; end of line? jnz cnvln3 ; nz = no jmp cnvlnx ; yes, exit now cnvln3: cmp al,'a' ; candidate for conversion? [js] jb cnvln4 ; b = no cmp al,'z' ; still in lower case set? [js] ja cnvln4 ; a = no and al,script.incasv ; else apply case conversion mask cnvln4: stosb ; save the char inc cx ; and count it or ah,ah ; was number larger than one byte? jz cnvln1 ; z = no xchg ah,al ; put high byte into al stosb ; store it too inc cx ; count storage jmp short cnvln1 ; read more cnvln5: mov dx,si ; get filename ptr from source line push si inc tempd ; count indirection depth mov cx,64 ; max length of a filename. cnvln5a:cmp byte ptr [si],' ' ; whitespace or control code? jbe cnvln5b ; be = yes, found termination inc si ; else look at next char loop cnvln5a ; limit search cnvln5b:mov byte ptr [si],0 ; make asciiz pop si mov ah,open2 ; DOS 2 open file xor al,al ; open for reading int dos mov word ptr fhandle,ax ; store file handle jnc cnvln7 ; nc = open ok, read from file mov ah,prstr mov dx,offset indmis ; file open error msg int dos xor cx,cx ; say zero bytes read pop di ; destination ptr pop si ; source ptr pop es pop tempd stc ; set c bit, failure ret cnvln7: mov bx,word ptr fhandle ; file handle mov cx,linelen ; # of bytes to read mov ah,ioctl ; ioctl, is this the console device? xor al,al ; get device info int dos and dl,81h ; ISDEV and ISCIN bits needed together cmp dl,81h ; Console input device? jne cnvln7d ; ne = no, use regular file i/o push ds pop es ; set es:di to data segment push di ; save starting pointer cnvln7b:mov ah,coninq ; read console, no echo int dos stosb cmp al,cr ; end of the line yet? loopne cnvln7b ; keep reading mov byte ptr [di],0 ; insert terminator pop di ; recover starting pointer mov dx,di ; simulate read file read mov ax,linelen sub ax,cx ; ax = number of chars read jmp short cnvln7e ; close file, finish processing cnvln7d:mov dx,di ; destination ptr mov byte ptr [di],0 ; insert null terminator, clears line mov ah,readf2 ; DOS 2 read from file int dos cnvln7e:pushf ; save flags push ax ; save byte count read mov ah,close2 ; close file (wanted just one line) int dos pop ax popf ; recover flags now jc cnvln8 ; c = error mov cx,ax ; ax = number of bytes read jcxz cnvln8a ; cx = z = no bytes read mov al,cr ; look for cr as terminator cld repne scasb ; scan while not a cr and cx not zero jne cnvln7a ; ne = no cr found dec di ; point at cr cnvln7a:mov byte ptr [di],0 ; plant terminator on the cr ; or after last read char, if no cr. pop di ; get original destination ptr push di ; and save it again mov si,dx ; new source = this line ; go convert text, as necessary, and jmp cnvln0 ; allow nested indirection cnvln8: mov ah,prstr mov dx,offset inderr ; error reading file message int dos cnvln8a:xor cx,cx ; say zero bytes read pop di pop si pop es pop tempd stc ; set carry for failure ret ; and do a real return cnvlnx: pop di ; destination ptr pop si ; source ptr pop es pop tempd clc ; clear c bit, success ret cnvlin endp ; ; worker: read the number of seconds to pause or timeout ; returns time of day for timeout in timhms, and next non-space or ; non-tab source char ptr in si. Time is either elapsed seconds or ; a specific hh:mm:ss, determined from context of colons being present. ; Last form can be abbreviated as hh:[mm[:ss]]. Returns carry set if ; hh:mm:ss form has bad construction (invalid time). inptim proc near push ax push bx push cx push dx push di cld ; decode pure seconds construction mov di,si ; remember source pointer mov cx,10 ; multiplier mov bx,script.indfto ; no numbers yet, use default-timeout mov al,byte ptr[si] cmp al,':' ; stray hh:mm:ss separator? je inptm8 ; e = yes cmp al,'9' ; start with numeric input? ja inptm4 ; a = no, use default time cmp al,'0' ; ditto jb inptm4 xor ah,ah ; source char holder xor bx,bx ; accumulated sum inptm1: mov al,byte ptr[si] ; get a byte into al cmp al,':' ; hh:mm:ss construction? je inptm8 ; e = yes sub al,'0' ; remove ascii bias cmp al,9 ; numeric? ja inptm4 ; a = non-numeric, exit loop, bx = sum xchg ax,bx ; put sum into ax, char in bl mul cx ; sum times ten xchg ax,bx ; put char into al, sum in bx add bx,ax ; add to sum inc si ; next char jmp short inptm1 ; loop thru all chars inptm4: cmp bx,12*60*60 ; half a day, in seconds jb inptm5 ; b = less than jmp inptm13 ; more than, error inptm5: push si ; save ending scan position for return mov timout,bx ; # seconds of timeout desired mov ah,gettim ; read DOS tod clock int dos mov timhms[0],ch ; hours mov timhms[1],cl ; minutes mov timhms[2],dh ; seconds mov timhms[3],dl ; hundredths of seconds mov bx,2 ; start with seconds field inptm6: mov ax,timout ; our desired timeout interval add al,timhms[bx] ; add current tod digit to interval adc ah,0 xor dx,dx ; clear high order part thereof mov cx,60 ; divide by 60 div cx ; compute number of minutes or hours mov timout,ax ; quotient mov timhms[bx],dl ; put remainder in timeout tod digit dec bx ; look at next higher order time field or bx,bx ; done all time fields? jge inptm6 ; ge = no cmp timhms[0],24 ; normalize hours jl inptm7 ; l = not 24 hours sub timhms[0],24 ; discard part over 24 hours inptm7: pop si ; return ptr to next source char jmp short inptm11 ; trim trailing whitespace inptm8: ; decode hh:[mm[:ss]] to timhms mov si,di ; recall starting source pointer mov word ptr timhms[0],0 ; clear time out tod mov word ptr timhms[2],0 xor bx,bx ; three groups possible inptm9: mov dl,byte ptr[si] ; get a char cmp dl,':' ; field separator? je inptm10 ; e = a separator, step fields sub dl,'0' ; remove ascii bias cmp dl,9 ja short inptm11 ; a = failure to get expected digit mov al,timhms[bx] ; get sum to al mov ah,10 mul ah ; sum times ten add al,dl ; sum = 10 * previous + current mov timhms[bx],al ; current sum cmp timhms[bx],60 ; more than legal? jae inptm13 ; ae = illegal or bx,bx ; doing hours? jnz inptm9a ; nz = no, min or sec cmp timhms[bx],24 ; more than legal? jae inptm13 ; ae = illegal inptm9a:inc si ; next char jmp short inptm9 ; continue analysis inptm10:inc bx ; point to next field inc si ; next char cmp bx,2 ; last subscript to use (secs) jbe inptm9 ; be = get more text inptm11:cmp byte ptr [si],spc ; examine break char, remove spaces jne inptm12 ; ne = no, stay at this char inc si ; look at next char jmp short inptm11 ; continue scanning off white space inptm12:clc ; carry clear for success jnc inptm14 inptm13:stc ; carry set for illegal value inptm14:pop di ; return with si beyond our text pop dx pop cx pop bx pop ax ret inptim endp ; worker: display the char in al on screen ; use caret-char notation for control codes scdisp proc near push dx push ax mov ah,conout ; our desired function test flags.remflg,d8bit ; show all 8 bits? jnz scdisp0 ; nz = yes and al,7fh ; apply 7 bit display mask scdisp0:or al,al ; null? jz scdis2 ; z = yes, ignore cmp al,del ; delete code? je scdis2 ; e = yes, ignore cmp al,spc ; control char? jae scdis1 ; ae = no, display as-is cmp al,cr ; carriage return? je scdis1 ; e = yes, display as-is cmp al,lf ; line feed? je scdis1 cmp al,tab ; horizontal tab? je scdis1 cmp al,bell ; bell? je scdis1 cmp al,bs ; backspace? je scdis1 cmp al,escape ; escape? je scdis1 or al,40h ; control code to printable char push ax mov dl,5eh ; display caret first int dos pop ax scdis1: mov dl,al ; the char to be displayed int dos scdis2: pop ax pop dx ret scdisp endp ; workers ; Circular buffer for data from serial port. Written by Joe R. Doupnik ; Entry points - ; bufread: read serial port for latest char (invokes bufwrite, sets ; status), get a char into al, return carry set if none. ; bufwrite: put a char from al into buf. If this overwrites an unread ; character then: we lose the old char, the read pointer ; is moved to the next oldest unread char, and the ; number of chars in the buffer is decreased by one. ; bufclear: empties the buffer. ; The buffer is prtbuf, of size scpbuflen bytes. Internally, integer bufcnt ; holds the number of buffer locations occupied, pointer bufrdptr is the ; offset of the char to be read, pointer bufwtptr is the offset of the ; place to store the next incoming char. ; bufclear proc near xor ax,ax ; create a zero mov bufcnt,ax ; clear count of bytes in buffer mov bufrdptr,ax ; move read pointer to start of buf mov bufwtptr,ax ; move write pointer to start of buf mov cx,scpbuflen push es ; physically clear the buffer push di mov ax,bufseg ; segment of port buffer mov es,ax xor al,al ; write scpbuflen nulls xor di,di cld shr cx,1 ; do an odd byte now jnc bufcle1 ; nc = no odd byte stosb bufcle1:rep stosw ; do double bytes (words) pop di pop es ret bufclear endp bufread proc near call chkport ; get any oldest char from port call chktmo ; check tod for timeout cmp bufcnt,0 ; empty buffer? jne bufrd1 ; ne = no stc ; yes, set carry flag (no char) ret ; and quit (chkport sets status) bufrd1: push si push es mov si,bufseg ; get buffer segment mov es,si mov si,bufrdptr mov al,es:[si] ; extract a char into al inc bufrdptr ; move pointer to next byte dec bufcnt ; say have extracted a char mov si,scpbuflen cmp bufrdptr,si ; beyond end? jb bufrd2 ; b = not yet, just return mov bufrdptr,0 ; reset to start of buf (wrapping) bufrd2: pop es pop si clc ; clear carry flag (have read a char) ret ; chkport sets status bufread endp ; Non-destructive read of serial port circular buffer. Requires external ; initialization of peek read pointer bufpkptr and count remaining bufpkcnt. ; Returns character in register al. peekbuf proc near cmp bufpkcnt,0 ; peek counter, empty buffer? jne peekbu2 ; ne = no, so look in buffer or status,stat_tmo ; force timeout status push si mov si,scpbuflen cmp bufcnt,si ; is real buffer full? pop si jae peekbu1 ; ae = yes, have examined everything call chkport ; get a char from port and status,not stat_tmo ; clear timeout call chktmo ; and check for timeout cmp bufcnt,0 ; still nothing from port? je peekbu1 ; e = no char, report fact inc bufpkcnt ; got one, increase peek counter jmp short peekbu2 ; go extract it peekbu1:stc ; return nothing to see ret peekbu2:push si push es mov si,bufseg ; segment of port buffer mov es,si mov si,bufpkptr ; buffer peek pointer mov al,es:[si] ; extract a char into al inc bufpkptr ; move pointer to next byte dec bufpkcnt ; say have extracted a char mov si,scpbuflen cmp bufpkptr,si ; beyond end? jb peekbu3 ; b = not yet, just return mov bufpkptr,0 ; reset to start of buf (wrapping) peekbu3:pop es pop si clc ; clear carry flag (have read a char) ret peekbuf endp bufwrite proc near push si push es mov si,bufseg ; segment of buffer mov es,si mov si,bufwtptr mov es:[si],al ; store char held in al inc bufwtptr ; move pointer to next byte mov si,scpbuflen ; length of buffer cmp bufwtptr,si ; beyond end? jb bufwt1 ; b = not yet mov bufwtptr,0 ; reset to start of buf (wrapping) bufwt1: inc bufcnt ; say have added a char to the buf cmp bufcnt,si ; more than we can hold? jbe bufwt3 ; be = not overflowing push bufwtptr ; read ptr can't alias write ptr pop bufrdptr ; move up read pointer mov bufcnt,si ; limit count to max buffer length bufwt3: pop es pop si ret bufwrite endp ; Report buffer status for dumping buffer to a log file. ; Yield ax, cx, es, si as indicated below. buflog proc near mov ax,bufcnt ; number of unread chars mov cx,scpbuflen ; length of buffer mov si,bufseg ; segment of buffer mov es,si mov si,bufrdptr ; where to read next char ret ; return these registers buflog endp ; worker: check for timeout, return status=stat_tmo if timeout, else bit ; stat_tmo is cleared. chktmo: and status,not stat_tmo mov ah,gettim ; get the time of day int dos sub ch,timhms[0] ; hours difference, ch = (now-timeout) je chktmo2 ; e = same, check mmss.s jg chktmo1 ; g = past target hour add ch,24 ; we are early, see by how much chktmo1:cmp ch,12 ; hours difference, large or small? jge chktmox ; ge = not that time yet jl chktmo3 ; l = beyond that time chktmo2:cmp cl,timhms[1] ; minutes, hours match jb chktmox ; b = early ja chktmo3 ; a = late cmp dh,timhms[2] ; seconds, hhmm match jb chktmox ; b = early ja chktmo3 ; a = late cmp dl,timhms[3] ; fractions, hhmmss match jb chktmox ; b = early chktmo3:or status,stat_tmo ; say timeout stc ret chktmox:clc ret ; ; worker: check keyboard for char. Return status = stat_cc if control-C typed, ; stat_cr if carriage return, or stat_ok if any other char typed. Else return ; with these status bits cleared. chkkbd: and status,not (stat_ok+stat_cc+stat_cr) ; clear status bits xor al,al cmp flags.cxzflg,'C' ; Control-C interrupt seen? je chkkbd0 ; e = yes call isdev ; is stdin a device, not disk file? jnc chkkbd2 ; nc = not device so do not read here mov ah,dconio ; keyboard char present? mov dl,0ffH int dos je chkkbd1 ; e = none or status,stat_ok ; have a char, return it in al cmp al,3 ; control c? jne chkkbd1 ; ne = not control c chkkbd0:or status,stat_cc ; say control c chkkbd1:cmp al,cr ; carriage return? [js] jne chkkbd2 ; ne = no or status,stat_cr ; say carriage return [js] chkkbd2:ret ; ; worker: check serial port for received char. Return status = stat_ok if ; char received, otherwise stat_ok cleared. Can echo char to screen. Will ; write char to local circular buffer. chkport:and status,not stat_ok ; clear status bit call prtchr ; char at port (in al)? jnc chkpor1 ; nc = yes, analyze it ret ; no, return chkpor1:and al,parmsk ; strip parity, if any cmp rxtable+256,0 ; is translation turned off? je chkpor0 ; e = yes, no translation push bx ; translate incoming character mov bx,offset rxtable ; the translation table xlatb pop bx chkpor0:test flags.capflg,logses ; capturing active? jz chkpor3 ; z = no test flags.remflg,d8bit ; keep 8 bits for displays? jnz chkpo0a ; nz = yes, 8 bits if possible cmp flags.debug,0 ; is debug mode active? jne chkpo0a ; ne = yes, record 8 bits and al,7fh ; remove high bit chkpo0a:push ax ; save char call cptchr ; give it captured character pop ax ; restore character and keep going chkpor3:test flags.remflg,d8bit ; keep 8 bits for displays? jnz chkpo3a ; nz = yes, 8 bits if possible and al,7fh ; remove high bit chkpo3a:cmp script.inecho,0 ; input echoing off? je chkpor4 ; e = yes call scdisp ; display the char chkpor4:call bufwrite ; put char in buffer or status,stat_ok ; say have a char (still in al) ret ; ; Squit is the script error exit pathway. ; squit: cmp flags.cxzflg,'C' ; Control-C interrupt seen? je squit5 ; e = yes test status,stat_tmo ; timeout? jz squit2 ; z = no, another kind of failure cmp taklev,0 ; in a Take/macro? jne squit1 ; ne = yes, skip timeout message push dx mov dx,offset tmomsg ; say timed out mov ah,prstr int dos ; display it pop dx squit1: cmp script.inactv,0 ; action to do upon timeout je squit4 ; 0 = proceed, ne = non-zero = quit squit5: call takclos ; close Take file or macro squit2: call isdev ; stdin is a device (vs file)? jc squit3 ; c = device, not a file mov flags.extflg,1 ; set Kermit exit flag squit3: cmp flags.cxzflg,'C' ; Control-C interrupt seen? jne squit6 ; ne = no or kstatus,ksuser ; say user intervention squit6: stc ret ; return failure squit4: clc ; return success, ignore error ret code ends end